package MAIN;
//笔试强训第8天
//选择题
/*原生类：是指基本数据类型。数组不是一个原生类，数组是一个对象*/
/*数组的大小是不可以任意改变大小的，凡是new出来的对象都在堆内存中进行存储*/
/*如果子类中重写了父类中的方法，在子类中调用这个方法的时候会优先调用子类重写过的这个方法，
* 如果子类中没有这个方法，再去父类中找。  try catch中的finally中的return会覆盖try中的
* return，但是这个覆盖不是绝对的，因为代码的执行是有顺序的，finally不管有没有异常，最后
* 都会执行finally中的语句。*/
/*如果程序中有静态代码块，一定是静态代码块先执行，如果有继承的关系，首先是父类的静态代码块，
* 然后是子类的静态代码块，然后执行其他的代码块*/
/*代码块的执行顺序：静态代码块 > 构造块 > 构造方法
* 父类静态代码块 > 子类静态代码块 > 父类构造快 > 父类构造方法 > 子类构造块 > 子类构造方法*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
//编程题
public class Main8 {
    //是否满足两种排序方法（字典和长度进行比较）

    //按照字典序进行排序（compareTo方法默认就是按照字典序进行比较）
    public static boolean isSortDit(String[] str) {
        //注意数组越界的问题
        for (int i = 0; i < str.length - 1; i++) {
            if (str[i].compareTo(str[i+1]) > 0) {
                //说明此时没有按照字典序进行排序
                return false;
            }
        }
        return true;
    }
    //按照字符串长度进行比较
    public static boolean isSortLength(String[] str) {
        //注意数组越界的问题
        for (int i = 0; i < str.length - 1; i++) {
            if (str[i].length() > str[i+1].length()) {
                return false;
            }
        }
        return true;
    }
    public static void main3(String[] args) throws IOException {
        //InputStreamReader可以把输入的字节流转化成字符流
        //BufferReader：从字符流中读取文本并且缓存
        //System.in的意思是输入是从键盘输入的
        //parseInt方法就是把一个字符串转化成一个整数
        BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(re.readLine());
        String[] strs = new String[n];

        for (int i = 0; i < n; i++) {
            //readLine就是把字符串从re中读取出来
            strs[i] = re.readLine();
        }
        //判断
        if (isSortDit(strs) && isSortLength(strs)) {
            System.out.println("both");
        }else if (isSortLength(strs)) {
            System.out.println("lengths");
        }else if (isSortDit(strs)) {
            System.out.println("lexicographically");
        }else {
            System.out.println("none");
        }
    }

    public static void main1(String[] args) {
        //求最小公倍数
        //思路：先找a b中的max值，然后去找最大值的倍数，什么时候这个倍数可以同时把
        //a和b都能整除，此时这个倍数就是a和b的最小公倍数
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        if (a < b) {
            int tmp = a;
            a = b;
            b = tmp;
        }
        for (int i = a; i > 0; i++) {
            if (i % a == 0 && i % b ==0) {
                System.out.println(i);
                break;
            }
        }
    }
//最小公倍数思路2
    public static void main(String[] args) {
        //最小公倍数 = a*b / a和b的最大公约数
        //找最大公约数：辗转相除法
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        //求最小公倍数
        int c = (a * b) / gdc(a,b);
        System.out.println(c);
    }
    public static int gdc(int a,int b) {
        //辗转相除法
        if (a == b) return a;
        if (a < b) {
            int tmp = a;
            a = b;
            b =tmp;
        }
        //肯定保证a是最大的
        int c;
        while ((c = a % b) > 0) {
            a = b;
            b = c;
        }
        return b;
    }
}
